#include<iostream>
using namespace std;

class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

	void Func(const Date& d)
	{
		//...
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{
		_t._minute++;
	}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};

//int main()
//{
//
//	return 0;
//}

//class A
//{
////public:
//private:
//	// 1、B这个类受A类的类域的限制
//	// 2、内部类天生就是外部类的友元类
//	class B
//	{
//	public:
//		void func(A* p)
//		{
//			p->_a1++;
//		}
//	private:
//		int _b1;
//	};
//
//	void fx(B* ptr)
//	{
//		//ptr->_b1++;
//	}
//
//private:
//	int _a1;
//	int _a2;
//};
//
////class B
////{
////private:
////	int _b1;
////};
////
////class A
////{
////public:
////private:
////	int _a1;
////	int _a2;
////	B _bb;
////};
//
//int main()
//{
//	cout << sizeof(A) << endl;
//	A aa;
//
//	//A::B bb;
//
//
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//
//class Solution {
//public:
//	int func(int n) {
//		cout << "int func(int n)" << endl;
//		//...
//		return n;
//	}
//};
//
//int main()
//{
//	// 有名对象
//	A aa1;
//	
//
//	// 匿名对象
//	// 生命周期只在当前一行
//	A();
//	A(10);
//
//	A aa2(10);
//
//	Solution sl;
//	sl.func(10);
//
//	Solution().func(1);
//
//	return 0;
//}

///////////////////////////////////////////////////////////////////////
// 编译器对于构造的一些优化
// 构造+拷贝
// 拷贝构造+拷贝构造
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

//void f1(A aa)
//{}
//
//void f2(const A& aa)
//{}
//
//int main()
//{
//	A aa1 = 2;  // 构造 + 拷贝构造 -》 直接构造
//	const A& aa2 = 2;
//
//	f1(aa1);
//
//	f1(A(2));   // 构造 + 拷贝构造 -》 直接构造
//
//	f2(aa1);
//
//	return 0;
//}

//A f4()
//{
//	return A();
//}
//
//A f3()
//{
//	A aa;
//	return aa;	
//}
//
//int main()
//{
//	// 拷贝构造+拷贝构造->拷贝构造
//	A ret = f3();
//
//	// 构造 + 拷贝构造 + 拷贝构造 ->构造
//	//A ret = f4();
//	//A ret;
//	//ret = f4();
//
//
//	return 0;
//}

//int main()
//{
//	int a = 0;
//	const int b = 1;
//	cout << &a << endl;
//	cout << &b << endl;
//
//	char char2[] = "abcd";
//	const char* pChar3 = "abcd";
//
//	char2[0]++;
//	((char*)pChar3)[0]++;
//
//
//	return 0;
//}

struct ListNode
{
	ListNode* _next;
	int _val;

	ListNode(int val)
		:_next(nullptr)
		, _val(val)
	{}
};

struct ListNode* CreateListNode(int val)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->_next = NULL;
	newnode->_val = val;
	return newnode;
}

// 创建的不带哨兵位
ListNode* CreateList(int n)
{
	ListNode head(-1);  // 哨兵位

	ListNode* tail = &head;
	int val;
	printf("请依次输入%d个节点的值：>", n);
	for (size_t i = 0; i < n; i++)
	{
		cin >> val;
		tail->_next = new ListNode(val);
		tail = tail->_next;
	}

	return head._next;
}

void func()
{
	int n = 1;
	while (1)
	{
		int* p = new int[1024 * 1024 * 100];
		//int* p = (int*)malloc(1024 * 1024*4);

		cout << n << "->" << p << endl;
		++n;
	}
}

int main()
{
	// 1、用法上，变简洁了
	int* p0 = (int*)malloc(sizeof(int));
	int* p1 = new int;
	int* p2 = new int[10]; // new 10个int对象

	// 2、可以控制初始化
	int* p3 = new int(10); // new 1个int对象,初始化成10
	int* p4 = new int[10] { 1, 2, 3, 4, 5 };

	// 3、自定义类型，开空间+构造函数
	// 4、new失败了以后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);
	//...
	//ListNode* list1 = CreateList(5);

	delete p3;
	delete[] p4;
	delete p1;
	delete[] p2;

	try
	{
		func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}